
#include "TLexico.h"



int TLexico_setError(TLexico *al, int codigo, char* mensaje)
{
    int i = 0;
    al->codigoError = codigo;

    for(i=0;i<100;i++)
    {
        al->mensajeError[i] = mensaje[i];
    }

    return 0;
}

int TLexico_getUltimoError(TLexico *al, int* codigo, char* mensaje)
{
    int i = 0;

    *codigo = al->codigoError;

    for(i=0;i<100;i++)
    {
         mensaje[i] = al->mensajeError[i];
    }

}

int TLexico_Crear(TLexico* al)
{
	al->longitud = 0;
	al->codigoError = 0;

	return 0;
}


int TLexico_setAnalizadorSintactico(TLexico* al, TSintactico* as)
{
	al->as = as;

	return 0;
}

int TLexico_PushChar(TLexico* al, char c)
{
	/*
	al->entrada[1] = c;
	al->longitud++;
	printf("lon:%d\n",al->longitud);
*/

	int index = al->longitud;
	al->entrada[index] = c;
	al->longitud++;

	return 0;
}

void AnalizarTokens(TLexico* al);

int TLexico_terminarFlujo(TLexico* al)
{
	AnalizarTokens(al);

	TSintactico_terminarFlujo(al->as);

	return 0;
}


Boolean EsNull(char *dato,int dataLength)
{

     if (   ((dato[0]== 'n') || (dato[0]== 'N'))
         && ((dato[1]== 'u') || (dato[1]== 'U'))
         && ((dato[2]== 'l') || (dato[2]== 'L'))
         && ((dato[3]== 'l') || (dato[3]== 'L'))
         && dataLength ==4
        )
        {
            return True;
        }
    else
        return False;

}

Boolean EsFalse(char *dato,int dataLength)
{

 if (   ((dato[0]== 'f') || (dato[0]== 'F'))
     && ((dato[1]== 'a') || (dato[1]== 'A'))
     && ((dato[2]== 'l') || (dato[2]== 'L'))
     && ((dato[3]== 's') || (dato[3]== 'S'))
     && ((dato[4]== 'e') || (dato[4]== 'E'))
     && dataLength == 5
    )
    {
        return True;
    }
    else
        return False;

}

Boolean EsTrue(char *dato,int dataLength)
{
    if (   ((dato[0]== 't') || (dato[0]== 'T'))
         && ((dato[1]== 'r') || (dato[1]== 'R'))
         && ((dato[2]== 'u') || (dato[2]== 'U'))
         && ((dato[3]== 'e') || (dato[3]== 'E'))
         && dataLength == 4
        )
    {
        return True;
    }
    else
        return False;
}

Boolean EsNumero(char *dato,int dataLength)
{
    Boolean isNumber = True;
    int i =0;


    for(i=0;i<dataLength;i++)
    {
        if ((dato[i]!='0')&&
            (dato[i]!='1')&&
            (dato[i]!='2')&&
            (dato[i]!='3')&&
            (dato[i]!='4')&&
            (dato[i]!='5')&&
            (dato[i]!='6')&&
            (dato[i]!='7')&&
            (dato[i]!='8')&&
            (dato[i]!='9'))
            isNumber = False;
    }

    return isNumber;
}


void VaciarBuffer(TLexico* al,int dataLength,Token *token)
{



    if (EsTrue(token->dato,dataLength))
    {

		token->tipo = TOKEN_TRUE;
		token->dato[dataLength] = 0;
		TSintactico_PushToken(al->as,token);

    }
    else if (EsFalse(token->dato,dataLength))
    {

		token->tipo = TOKEN_FALSE;
		token->dato[dataLength] = 0;
		TSintactico_PushToken(al->as,token);

    }
    else if (EsNull(token->dato,dataLength))
    {

 		token->tipo = TOKEN_NULL;
 		token->dato[dataLength] = 0;
		TSintactico_PushToken(al->as,token);
    }
    else if (EsNumero(token->dato,dataLength))
    {

        token->tipo = TOKEN_NUMERO;
        token->dato[dataLength] = 0;
		TSintactico_PushToken(al->as,token);
    }
    else
    {
        TLexico_setError(al, 1, "No se pudo determinar el token");

        token->tipo = TOKEN_ERROR_LEXICO;
        token->dato[dataLength] = 0;
		TSintactico_PushToken(al->as,token);
    }


}




void AnalizarTokens(TLexico* al)
{
    int entradaIndex = 0;

    int tokenIndex = 0;
    int dataIndex = 0;

    Token token;


    Boolean armandoString = False;
    int aux = 0;


    for(entradaIndex=0;entradaIndex<al->longitud;entradaIndex++)
    {


            switch(al->entrada[entradaIndex])
            {
                case  '{':
                {
                    if (!armandoString)
                    {
                        dataIndex = 0;

                        token.tipo = TOKEN_OBJETO_EMPIEZA;
                        token.dato[dataIndex] = '{';
                        token.dato[dataIndex+1] = 0;

                        TSintactico_PushToken(al->as,&token);
                    }
                    else
                    {
                        token.tipo = TOKEN_ERROR_LEXICO;
                        TLexico_setError(al, 1, "No se pudo determinar el token");
                        token.dato[dataIndex] = 0;

                        TSintactico_PushToken(al->as,&token);
                    }
                    break;
                }
                case  '}':
                {
                    if (!armandoString)
                    {
                        if (dataIndex>0)
                            VaciarBuffer(al,dataIndex,&token);



                        dataIndex = 0;

                        token.tipo = TOKEN_OBJETO_TERMINA;
						token.dato[dataIndex] = '}';
						token.dato[dataIndex+1] = 0;

						TSintactico_PushToken(al->as,&token);
                    }
                    else
                    {
                        token.tipo = TOKEN_ERROR_LEXICO;
                        token.dato[dataIndex] = 0;
                        TLexico_setError(al, 1, "No se pudo determinar el token");

                        TSintactico_PushToken(al->as,&token);
                    }
                    break;
                }
                case  '[':
                {
                    if (!armandoString)
                    {
                        dataIndex = 0;

                        token.tipo = TOKEN_ARRAY_EMPIEZA;
						token.dato[dataIndex] = '[';
						token.dato[dataIndex+1] = 0;

						TSintactico_PushToken(al->as,&token);
                    }
                    else
                    {
                        token.tipo = TOKEN_ERROR_LEXICO;
                        token.dato[dataIndex] = 0;
                        TLexico_setError(al, 1, "No se pudo determinar el token");

                        TSintactico_PushToken(al->as,&token);
                    }
                    break;
                }
                case  ']':
                {
                    if (!armandoString)
                    {
                        if (dataIndex>0)
                            VaciarBuffer(al,dataIndex,&token);

                        dataIndex = 0;

                        token.tipo = TOKEN_ARRAY_TERMINA;
						token.dato[dataIndex] = ']';
						token.dato[dataIndex+1] = 0;

						TSintactico_PushToken(al->as,&token);
                    }
                    else
                    {
                        token.tipo = TOKEN_ERROR_LEXICO;
                        token.dato[dataIndex] = 0;
                        TLexico_setError(al, 1, "No se pudo determinar el token");

                        TSintactico_PushToken(al->as,&token);
                    }
                    break;
                }
                case ':':
                {
                    if (!armandoString)
                    {
                        dataIndex = 0;

                        token.tipo = TOKEN_DOSPUNTOS;
                        token.dato[dataIndex] = ':';
                        token.dato[dataIndex+1] = 0;

						TSintactico_PushToken(al->as,&token);

                    }
                    else
                    {
                        token.tipo = TOKEN_ERROR_LEXICO;
                        token.dato[dataIndex] = 0;
                        TLexico_setError(al, 1, "No se pudo determinar el token");

                        TSintactico_PushToken(al->as,&token);
                    }

                    break;
                }
                case ',':
                {
                    if (!armandoString)
                    {
                        if (dataIndex>0)
                            VaciarBuffer(al,dataIndex,&token);

                        dataIndex = 0;

                        token.tipo = TOKEN_COMA;
                        token.dato[dataIndex] = ',';
                        token.dato[dataIndex+1] = 0;

						TSintactico_PushToken(al->as,&token);

                    }
                    else
                    {
                        token.tipo = TOKEN_ERROR_LEXICO;
                        token.dato[dataIndex] = 0;
                        TLexico_setError(al, 1, "No se pudo determinar el token");

                        TSintactico_PushToken(al->as,&token);
                    }
                    break;
                }
                case '\"':
                {
                    armandoString = !armandoString;

                    if (!armandoString)
                    {
                        token.tipo = TOKEN_STRING;

                        token.dato[dataIndex] = 0;

						TSintactico_PushToken(al->as,&token);

                        dataIndex = 0;
                    }

                    break;
                }
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                case 'g':
                case 'h':
                case 'i':
                case 'j':
                case 'k':
                case 'l':
                case 'm':
                case 'n':
                case 'o':
                case 'p':
                case 'q':
                case 'r':
                case 's':
                case 't':
                case 'u':
                case 'v':
                case 'w':
                case 'x':
                case 'y':
                case 'z':
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                case 'G':
                case 'H':
                case 'I':
                case 'J':
                case 'K':
                case 'L':
                case 'M':
                case 'N':
                case 'O':
                case 'P':
                case 'Q':
                case 'R':
                case 'S':
                case 'T':
                case 'U':
                case 'V':
                case 'W':
                case 'X':
                case 'Y':
                case 'Z':
                {
					token.dato[dataIndex] = al->entrada[entradaIndex];

					dataIndex++;

                    break;
                }
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                {
                    if (!armandoString)
                    {
                        token.dato[dataIndex] = al->entrada[entradaIndex];
                        dataIndex++;
                    }
                    else
                    {
                        token.tipo = TOKEN_ERROR_LEXICO;
                        token.dato[dataIndex] = 0;
                        TLexico_setError(al, 1, "No se pudo determinar el token");

                        TSintactico_PushToken(al->as,&token);
                    }

                    break;
                }


            }
    }



}

